package com.flex.core.dao;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.persistence.Table;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

import com.flex.core.model.AbstractIdEntity;
import com.flex.core.utils.DateUtil;

/**
 * jdbcTemplate的封装类，主要提供封装后的方法，如将原始返回类型中的Map反射成Pojo
 * 
 * @author sam
 * 
 */
@Component
public class JdbcDao {
	@Autowired
	private JdbcTemplate jdbcTemplate;

	public JdbcDao(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}

	/**
	 * 分页，返回page的result中为map类型<br/>Sample:<br/>Page page = pagedQuery("select *
	 * from p_advertisment",2,10);<br/>
	 * 
	 * 部分代码请参见pagedQuery(Class persistentClass, String sql, int pageNo, int
	 * pageSize)
	 * 
	 * 
	 * @param sql
	 *            sql语句
	 * @param pageNo
	 *            起始页
	 * @param pageSize
	 *            每页大小
	 * @return page对象
	 */
	public Page pagedQuery(String sql, int pageNo, int pageSize,
			Object... values) {
		return pagedQuery(null, sql, pageNo, pageSize, values);
	}

	/**
	 * 分页，返回page的result中为pojo类型<br/>Sample:<br/>Page page =
	 * pagedQuery(Advertisment.Class,"select * from p_advertisment",2,10);<br/>
	 * 部分代码请参见Page
	 * 
	 * @param persistentClass
	 *            类型
	 * @param sql
	 *            sql语句
	 * @param pageNo
	 *            起始页
	 * @param pageSize
	 *            每页大小
	 * @return page对象
	 */
	@SuppressWarnings("unchecked")
	public Page pagedQuery(Class persistentClass, String sql, int pageNo,
			int pageSize, Object... values) {
		Assert.hasText(sql);
		Assert.isTrue(pageNo >= 1, "pageNo should start from 1");
		// Count查询
		String countQueryString = " select count(*) "
				+ removeSelect(removeOrders(sql));
		List countlist = getMapList(countQueryString, values);
		boolean groupByFlag = false;
		if (countQueryString.indexOf("group by") > 0) {
			groupByFlag = true;
		}
		long totalCount = 0;
		if (countlist != null && !countlist.isEmpty()) {
			if (groupByFlag) {
				totalCount = Long.valueOf(countlist.size());
			} else {
				String results = countlist.get(0).toString();
				int temp = results.indexOf("=");
				totalCount = Long.parseLong(results.substring(temp + 1,
						temp + 2));
			}
		}
		if (totalCount < 1)
			return new Page();
		// 实际查询返回分页对象
		int startIndex = Page.getStartOfPage(pageNo, pageSize);
		sql += " limit " + startIndex + "," + pageSize;
		List list = getMapList(sql, values);
		if (null != persistentClass) {
			list = getObjList(persistentClass, sql, values);
		}
		return new Page(startIndex, totalCount, pageSize, list);
	}

	/**
	 * 保存或更新对象，传入对象必须继承于AbstractEntity类，否则操作无效<br/>Sample:<br/>保存的例子:<br/>Advertisment
	 * adv = new Advertisment();<br/>adv.setId("1");<br/>adv.setName("advertisment1");<br/>saveOrUpdate(adv);<br/>
	 * 更新的例子:<br/>Advertisment adv = get(1,Advertisment.Class);<br/>adv.setName("advertisment2");<br/>
	 * saveOrUpdate(adv);<br/>
	 * 
	 * @param obj
	 *            要保存的对象
	 */
	// @SuppressWarnings("unchecked")
	// public void saveOrUpdate(Object obj) {
	// if (obj instanceof AbstractEntity) {
	// AbstractEntity entityDao = (AbstractEntity) obj;
	// if (entityDao.getId() == null) {
	// save(obj);
	// } else {
	// update(obj);
	// }
	// }
	// }
	/**
	 * 保存对象<br/>Sample:<br/>Advertisment adv = new Advertisment();<br/>adv.setId("1");<br/>adv.setName("advertisment1");<br/>save(adv);<br/>
	 * 
	 * @param obj
	 *            要保存的对象
	 */
	public <T> T save(Object obj) {
		obj = saveOrUpdateObj(obj, "save");
		return saveOrUpdateObj(obj, "save");
	}

	/**
	 * 更新对象<br/>Sample:<br/>Advertisment adv = get(1,Advertisment.Class);<br/>adv.setName("advertisment2");<br/>
	 * update(adv);<br/>
	 * 
	 * @param obj
	 *            要更新的对象
	 */
	public <T> T update(Object obj) {
		return saveOrUpdateObj(obj, "update");
	}

	/**
	 * 更新对象<br/>Sample:<br/>Advertisment adv = get(1,Advertisment.Class);<br/>adv.setName("advertisment2");<br/>
	 * update(adv,"id");<br/>
	 * 
	 * @param obj
	 *            要更新的对象
	 * @param indexKey
	 *            表的主键
	 */
	@SuppressWarnings("unchecked")
	public void update(Object obj, String indexKey) {
		Class persistentClass = obj.getClass();
		String tableName = getTableName(persistentClass);
		Map<String, Object> hashMap = setObjToMap(obj);
		String sql = "";
		sql = generateUpdateSql(hashMap, tableName, indexKey);
		excute(sql);
	}

	/**
	 * 将所有的属性对应进行封装<br/>Sample:<br/>Advertisment adv =
	 * get(1,Advertisment.Class);<br/>Map<String,Object> map =
	 * setObjToMap(adv);<br/>返回的结果为进行匹配后的map结果集 *
	 * 
	 * @param obj
	 *            要转换的对象
	 * @return 进行匹配后的map结果集
	 */
	@SuppressWarnings("unchecked")
	public Map setObjToMap(Object obj) {
		Map hashMap = new HashMap();
		return setPojoToMap(obj, null, hashMap);
	}

	/**
	 * 根据sql语句和参数获取队列<br/>部分代码请参见getObjList(persistentClass, sql, values)
	 * 
	 * @param persistentClass
	 *            类型
	 * @param sql
	 *            sql语句
	 * @param values
	 *            参数的数组
	 * @return 查询的结果集，结果集中的每个元素为pojo对象
	 */
	@SuppressWarnings("unchecked")
	public <T> List<T> find(Class<T> persistentClass, String sql,
			Object... values) {
		return getObjList(persistentClass, sql, values);
	}

	/**
	 * 根据sql语句和参数获取唯一结果<br/>部分代码请参见getObj(persistentClass, sql, values)
	 * 
	 * @param persistentClass
	 *            类型
	 * @param sql
	 *            sql语句
	 * @param values
	 *            参数的数组
	 * @return 查询的结果，pojo对象
	 */
	public <T> T findUnique(Class<T> persistentClass, String sql,
			Object... values) {
		return getObj(persistentClass, sql, values);
	}

	/**
	 * 根据类中的某个字段，获取符合条件的结果集<br/>Sample:<br/>List<Advertisment> list =
	 * findByProperty(Advertisment.Class,"category",1);<br/>
	 * 
	 * @param persistentClass
	 *            类型
	 * @param propertyName
	 *            字段名
	 * @param value
	 *            条件值
	 * @return 符合条件的结果集，类型为pojo对象
	 */
	public <T> List<T> findByProperty(Class<T> persistentClass,
			String propertyName, Object value) {
		String sql = getSqlByTableAndProperty(persistentClass, propertyName,
				value);
		return getObjList(persistentClass, sql.toString());
	}

	/**
	 * 根据类中的某个字段，获取符合条件的一条结果<br/>Sample:<br/>Advertisment adv =
	 * findByProperty(Advertisment.Class,"category",1);<br/>
	 * 
	 * @param persistentClass
	 *            类型
	 * @param propertyName
	 *            字段名
	 * @param value
	 *            条件值
	 * @return 符合条件的一条记录，类型为pojo对象
	 */
	public <T> T findUniqueByProperty(Class<T> persistentClass,
			String propertyName, Object value) {
		String sql = getSqlByTableAndProperty(persistentClass, propertyName,
				value);
		return getObj(persistentClass, sql.toString());
	}

	/**
	 * 根据传入的类名，获取该类在数据库中的所有结果集，类型为pojo对象<br/>getAll(Advertisment.Class);<br/>
	 * 
	 * @param persistentClass
	 *            类名
	 * @return 该类在数据库中的所有结果集
	 */
	@SuppressWarnings("unchecked")
	public <T> List<T> getAll(Class<T> persistentClass) {
		String selectSql = getSelectSql(persistentClass);
		return getObjList(selectSql, persistentClass);
	}

	/**
	 * 根据id获取该类在数据库中的结果，返回类型为pojo<br/>Sample:<br/>get(1,Advertisment.Class);<br/>
	 * 
	 * @param id
	 *            id
	 * @param persistentClass
	 *            pojo的类型
	 * @return pojo对象
	 */
	public <T> T get(Integer id, Class<T> persistentClass) {
		StringBuffer sql = new StringBuffer();
		sql.append(getSelectSql(persistentClass)).append(" where id = ")
				.append(id);
		return getObj(sql.toString(), persistentClass);
	}

	/**
	 * 根据sql语句返回队列,类型为map<br/>Sample:<br/>getMapList("select * from
	 * p_advertisment");<br/>
	 * 
	 * @param sql
	 *            要执行的sql语句
	 * @return 符合条件的数据结果集，队列中的每个对象为Map类型
	 */
	@SuppressWarnings("unchecked")
	public <T> List<T> getMapList(String sql) {
		return getMapList(sql, new Object[] {});
	}

	/**
	 * 根据sql语句和数组中的参数返回队列,类型为map<br/>Sample:<br/>getMapList("select * from
	 * p_advertisment where id = ?",new Object[]{1});<br/>部分代码请参见JdbcTemplate
	 * 
	 * @param sql
	 *            要执行的sql语句
	 * @param values
	 *            参数的数组
	 * @return 符合条件的数据结果集，队列中的每个对象为Map类型
	 * 
	 */
	@SuppressWarnings("unchecked")
	public <T> List<T> getMapList(String sql, Object... values) {
		if (values == null) {
			return jdbcTemplate.queryForList(sql);
		} else {
			return jdbcTemplate.queryForList(sql, values);
		}
	}

	/**
	 * 根据sql语句和参数返回队列，类型为pojo类型<br/>Sample:<br/>getObjList("select * from
	 * p_advertisment where id > ?",new Object[]{1},Advertisment.Class);<br/>
	 * 
	 * @param sql
	 *            要执行的sql语句
	 * @param values
	 *            参数的数组
	 * @param persistentClass
	 *            需要返回的pojo的类型
	 * @return 符合条件的数据结果集，队列中的每个对象为pojo类型
	 */
	@SuppressWarnings("unchecked")
	public <T> List<T> getObjList(Class<T> persistentClass, String sql,
			Object... values) {
		List<Map> list = getMapList(sql, values);
		List<T> result = new ArrayList<T>();
		for (Map map : list) {
			result.add((T) setMapToObj(map, persistentClass));
		}
		return result;
	}

	/**
	 * 根据sql语句和参数返回队列，类型为pojo类型<br/>Sample:<br/>getObjList("select * from
	 * p_advertisment where id > 2",Advertisment.Class);<br/>
	 * 
	 * @param sql
	 *            要执行的sql语句
	 * @param persistentClass
	 *            需要返回的pojo的类型
	 * @return 符合条件的数据结果集，队列中的每个对象为pojo类型
	 */
	public <T> List<T> getObjList(String sql, Class<T> persistentClass) {
		return getObjList(persistentClass, sql, new Object[] {});
	}

	/**
	 * 根据sql语句返回指定类型的结果<br/>Sample:<br/>getObj("select * from p_advertisment
	 * where id = 2",Advertisment.Class);<br/>
	 * 
	 * @param sql
	 *            要执行的sql语句
	 * @param persistentClass
	 *            需要返回的pojo的类型
	 * @return 符合条件的记录，类型为参数中pojo的类型
	 */
	@SuppressWarnings("unchecked")
	public <T> T getObj(String sql, Class<T> persistentClass) {
		return getObj(persistentClass, sql, new Object[] {});
	}

	/**
	 * 根据sql语句返回指定类型的结果<br/>Sample:<br/>getObj("select * from p_advertisment
	 * where id = ?",new Object[]{1},Advertisment.Class);<br/>
	 * 
	 * @param sql
	 *            要执行的sql语句
	 * @param values
	 *            参数的数组
	 * @param persistentClass
	 *            需要返回的pojo的类型
	 * @return 符合条件的记录，类型为参数中pojo的类型
	 */
	@SuppressWarnings("unchecked")
	public <T> T getObj(Class<T> persistentClass, String sql, Object... values) {
		Map<String, Object> map = getMap(sql, values);
		return setMapToObj(map, persistentClass);
	}

	/**
	 * 执行sql语句<br/>部分代码请参见JdbcTemplate
	 * 
	 * @param sql
	 *            要执行的sql语句
	 * 
	 */
	public void excute(String sql) {
		jdbcTemplate.execute(sql);
	}

	/**
	 * 将map转换成pojo类型<br/>Sample:<br/>Map<String,Object> map = new HashMap<String,Object>;<br/>
	 * map.put("id",1);<br/>map.put("name","sam");<br/>
	 * setMapToObj(map,Advertisment.Class);<br/>
	 * 
	 * @param map
	 *            数据结果集
	 * @param persistentClass
	 *            需要返回的pojo的类型
	 * @return 反射后的pojo对象
	 */
	@SuppressWarnings("unchecked")
	private <T> T setMapToObj(Map<String, Object> map, Class<T> persistentClass) {
		if (map == null) {
			return null;
		}
		T bean = null;
		try {
			bean = persistentClass.newInstance();
			for (Map.Entry<String, Object> entry : map.entrySet()) {
				Field field = null;
				// 项目中字段与数据库映射规则为cityName--city_name,在反射中取出来的为带"_"的，所以进行处理
				String key = entry.getKey();
				int temp = key.indexOf("_");
				if (temp > 0) {
					String first = key.substring(0, temp);
					String sec = key.substring(temp + 1, temp + 2)
							.toUpperCase();
					String third = key.substring(temp + 2, key.length());
					StringBuffer sb = new StringBuffer();
					sb.append(first).append(sec).append(third);
					key = sb.toString();
				}
				try {
					field = persistentClass.getDeclaredField(key);
				} catch (NoSuchFieldException e) {
					// 到该类的父类中去找
					try {
						field = persistentClass.getSuperclass()
								.getDeclaredField(key);
					} catch (NoSuchFieldException e1) {
						// 到该类的父类的父类中去找
						try {
							field = persistentClass.getSuperclass()
									.getSuperclass().getDeclaredField(key);
						} catch (NoSuchFieldException e2) {
							// 目前项目中的pojo的子父类关系最多为三级，所以超出3级后就直接抛出异常了
							e2.printStackTrace();
						}
					}
				}
				field.setAccessible(true);
				field.set(bean, entry.getValue());
			}
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		}
		return bean;
	}

	/**
	 * 执行sql语句以及参数,返回结果为map类型
	 * 
	 * @param sql
	 *            要执行的sql语句
	 * @param values
	 *            参数的数组
	 * @return 结果集，类型为map
	 */
	@SuppressWarnings("unchecked")
	public Map<String, Object> getMap(String sql, Object... values) {
		Map<String, Object> resultMap = null;
		List<Map<String, Object>> resultList = jdbcTemplate.queryForList(sql,
				values);
		if (resultList != null && resultList.size() > 0) {
			resultMap = resultList.get(0);
		}
		return resultMap;
	}

	/**
	 * 生成更新对象的sql语句
	 * 
	 * @param map
	 *            保存字段的对应的map
	 * @param tableName
	 *            保存的表名
	 * @param indexKey
	 * @param indexKey
	 * @return 生成的sql语句
	 */
	private String generateUpdateSql(Map<String, Object> map, String tableName,
			String indexKey) {
		if (indexKey == null || indexKey.trim().equals("")) {
			indexKey = "id";
		}
		StringBuffer sb = new StringBuffer();
		sb.append("update ").append(tableName).append(" set ");
		Integer id = (Integer) map.get(indexKey);
		map.remove(indexKey);
		Iterator<String> it = map.keySet().iterator();
		int temp = 0;
		while (it.hasNext()) {
			String key = it.next();
			Object value = map.get(key);
			if (value != null) {
				if (temp > 0) {
					sb.append(",");
				}
				sb.append(key).append("='");
				if (value instanceof Date) {
					sb.append(DateUtil.dateTimeFormatter((Date) value));
				} else {
					sb.append(value);
				}
				sb.append("'");
				temp++;
			}
		}
		sb.append(" where ").append(indexKey).append(" = '").append(id).append(
				"'");
		return sb.toString();
	}

	/**
	 * 生成保存对象的sql语句
	 * 
	 * @param map
	 *            保存字段的对应的map
	 * @param tableName
	 *            保存的表名
	 * @return 生成的sql语句
	 */
	private String generateAddSql(Map<String, Object> map, String tableName) {
		StringBuffer sb = new StringBuffer();
		sb.append("insert into ").append(tableName);
		StringBuffer properties = new StringBuffer("(");
		StringBuffer values = new StringBuffer(" values(");
		Iterator<String> it = map.keySet().iterator();
		int temp = 0;
		while (it.hasNext()) {
			String key = it.next();
			Object value = map.get(key);
			if (value != null) {
				if (temp > 0) {
					properties.append(",");
					values.append(",");
				}
				properties.append(key);
				values.append("'");
				if (value instanceof Date) {
					values.append(DateUtil.dateTimeFormatter((Date) value));
				} else {
					values.append(value);
				}
				values.append("'");
				temp++;
			}
		}
		sb.append(properties).append(")").append(values).append(")");
		return sb.toString();
	}

	/**
	 * 将pojo的属性加入到map中
	 * 
	 * @param obj
	 *            pojo对象
	 * @param persistentClass
	 *            匹配类型
	 * @param hashMap
	 *            返回的map结果集
	 * @return 本次迭代后匹配的map结果集
	 */
	@SuppressWarnings("unchecked")
	private Map<String, Object> setPojoToMap(Object obj,
			Class<?> persistentClass, Map hashMap) {
		if (persistentClass == null) {
			persistentClass = obj.getClass();
		} else {
			persistentClass = persistentClass.getSuperclass();
		}
		try {
			Method m[] = persistentClass.getDeclaredMethods();
			for (int i = 0; i < m.length; i++) {
				if (m[i].getName().indexOf("get") == 0) {
					String key = m[i].getName();
					// 第一个字母转成小写，别的不变
					StringBuffer sb = new StringBuffer(key.substring(3, 4)
							.toLowerCase());
					sb.append(key.substring(4, key.length()));
					key = sb.toString();
					if (key.toLowerCase().equals(key)) {
						hashMap.put(key, m[i].invoke(obj, new Object[0]));
					} else {
						while (!key.toLowerCase().equals(key)) {
							int maxLen = key.length();
							boolean flag = true;
							for (int k = 0; k < maxLen; k++) {
								String temp = key.substring(k, k + 1);
								if (!temp.toLowerCase().equals(temp)) {
									sb = new StringBuffer();
									sb.append(key.substring(0, k)).append("_")
											.append(temp.toLowerCase()).append(
													key
															.substring(k + 1,
																	maxLen));
									key = sb.toString();
									flag = false;
								}
								if (k == maxLen - 1
										|| key.toLowerCase().equals(key)) {
									try {
										hashMap.put(key, m[i].invoke(obj,
												new Object[0]));
									} catch (Exception e) {
									}
								}
								if (!flag) {
									break;
								}
							}
						}
					}
				}
			}
		} catch (Throwable e) {
			e.printStackTrace();
		}
		if (persistentClass.getSuperclass() == AbstractIdEntity.class) {
			return hashMap;
		} else {
			return setPojoToMap(obj, persistentClass, hashMap);
		}
	}

	/**
	 * 根据pojo以及操作类型，保存或更新对象
	 * 
	 * @param obj
	 * @param type
	 * @param indexKey
	 */
	@SuppressWarnings("unchecked")
	private <T> T saveOrUpdateObj(Object obj, String type) {
		Class persistentClass = obj.getClass();
		String tableName = getTableName(persistentClass);
		Map<String, Object> hashMap = setObjToMap(obj);
		String sql = "";
		if (type.equals("save")) {
			sql = generateAddSql(hashMap, tableName);
		}
		if (type.equals("update")) {
			sql = generateUpdateSql(hashMap, tableName, null);
		}
		excute(sql);
		sql = generateInsetSql(hashMap, tableName);
		Map<String, Object> map = jdbcTemplate.queryForMap(sql);
		return (T) setMapToObj(map, persistentClass);
	}

	/**
	 * 生成查询语句
	 * 
	 * @param map
	 * @param tableName
	 * @return
	 */
	private String generateInsetSql(Map<String, Object> map, String tableName) {
		StringBuffer sb = new StringBuffer();
		sb.append("select * from ").append(tableName).append(" where ");
		Iterator<String> it = map.keySet().iterator();
		int temp = 0;
		while (it.hasNext()) {
			String key = it.next();
			Object value = map.get(key);
			if (value != null) {
				if (temp > 0) {
					sb.append(" and ");
				}
				sb.append(key).append(" = '");
				if (value instanceof Date) {
					sb.append(DateUtil.dateTimeFormatter((Date) value));
				} else {
					sb.append(value);
				}
				sb.append("'");
				temp++;
			}
		}
		return sb.toString();
	}

	/**
	 * 去除hql的select 子句，未考虑union的情况,用于pagedQuery.<br/>
	 * 
	 * 部分代码请参见pagedQuery(String,int,int,Object[])
	 */
	private String removeSelect(String hql) {
		Assert.hasText(hql);
		int beginPos = hql.toLowerCase().indexOf("from");
		Assert.isTrue(beginPos != -1, " hql : " + hql
				+ " must has a keyword 'from'");
		return hql.substring(beginPos);
	}

	/**
	 * 去除hql的orderby 子句，用于pagedQuery.
	 * 
	 * 部分代码请参见pagedQuery(String,int,int,Object[])
	 */
	private String removeOrders(String hql) {
		Assert.hasText(hql);
		Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*",
				Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(hql);
		StringBuffer sb = new StringBuffer();
		while (m.find()) {
			m.appendReplacement(sb, "");
		}
		m.appendTail(sb);
		return sb.toString();
	}

	/**
	 * 根据表名和字段，生成查询的sql语句
	 * 
	 * @param persistentClass
	 *            类名
	 * @param propertyName
	 *            字段名
	 * @param value
	 *            值
	 * @return
	 */
	@SuppressWarnings("unchecked")
	private String getSqlByTableAndProperty(Class persistentClass,
			String propertyName, Object value) {
		String tableName = getTableName(persistentClass);
		StringBuffer sql = new StringBuffer();
		sql.append("select * from ").append(tableName).append(" where ")
				.append(propertyName).append(" = '");
		if (value instanceof Date) {
			sql.append(DateUtil.dateTimeFormatter((Date) value));
		} else {
			sql.append(value);
		}
		sql.append("'");
		return sql.toString();
	}

	/**
	 * 根据传入的类名生成默认的sql语句<br/>Sample:<br/>getSelectSql(Advertisment.Class);<br/>返回语句为:select *
	 * from p_advertisement;<br/>
	 * 
	 * @param persistentClass
	 *            类名
	 * @return 返回查询该类所有的sql语句
	 */
	private String getSelectSql(Class<?> persistentClass) {
		String tableName = getTableName(persistentClass);
		StringBuffer sql = new StringBuffer();
		sql.append("select * from ").append(tableName);
		return sql.toString();
	}

	/**
	 * 根据 persistentClass 获取 Table name
	 * 
	 * @param persistentClass
	 *            类名
	 * @return 类名映射的数据库表的名称
	 */
	private String getTableName(Class<?> persistentClass) {
		String tableName = persistentClass.getSimpleName().toUpperCase();
		if (persistentClass.isAnnotationPresent(Table.class)) {
			Table table = persistentClass.getAnnotation(Table.class);
			if (table.name().trim().length() > 0) {
				tableName = table.name();
			}
		}
		return tableName;
	}
}
